BCI NET 2/BCI NET 2.iso/archives/programming/source/obrn-a_1.5_src.lha/oberon-a/source3.lha/Source/ORU/ORU.mod

Text File | 1995-01-26 | 21.0 KB | 738 lines

(*************************************************************************

     $RCSfile: ORU.mod $
  Description: Generates a script file that will recompile modules
               dependant on a given module.

   Created by: fjc (Frank Copeland)
    $Revision: 2.8 $
      $Author: fjc $
        $Date: 1995/01/26 02:13:59 $

  Copyright © 1993-1995, Frank Copeland
  This module forms part of the ORU program
  See ORU.doc for conditions of use and distribution

  Log entries are at the end of the file.

*************************************************************************)

<* STANDARD- *>

MODULE ORU;

IMPORT
  SYS := SYSTEM, ORURev, Errors, E := Exec, D := Dos, IU := IntuiUtil,
  Args, Out, Str := Strings, L := Lists, Files;

CONST
  CopyrightStr = "Copyright © 1993-1995 Frank Copeland\n";
  UsageStr = "See ORU.doc for conditions of use\n";

CONST
  MaxPaths         = 32;        (* Maximum number of search paths. *)
  SymPattern       = "#?.sym";  (* Pattern to search for symbol files. *)
  DefaultExtension = ".mod";    (* Default extension for source files. *)
  DefaultPath      = "OLIB:";   (* Default path for symbols *)

  SymFileTag       = 53594D08H; (* "SYM" + version # *)
  eMod = 26;                    (* Symbol file internal tags *)

  (* Error messages *)
  OutOfMem  = " !! Out of memory\n";
  OpenError = "\x9B\x4B !! Could not open ";

VAR
  NotCD       : BOOLEAN;  (* Don't search current directory if TRUE. *)
  All         : BOOLEAN;  (* Process all modules in search directories. *)
  Symbols     : ARRAY MaxPaths + 1 OF E.LSTRPTR;
                          (* Search paths for symbol files. *)
  NumSymbols  : INTEGER;  (* Number of paths specified. *)
  Source      : ARRAY MaxPaths + 1 OF E.LSTRPTR;
                          (* Search paths for source files. *)
  NumSources  : INTEGER;  (* Number of paths specified. *)
  Destination : E.LSTRPTR; (* Destination directory for batch file. *)
  Extension   : E.LSTRPTR; (* File extension for source files. *)
  Module      : E.LSTRPTR; (* Name of redefined module. *)

CONST
  MaxName = 31;

TYPE

  ModName = ARRAY MaxName + 1 OF CHAR;

  MNodePtr = POINTER TO MNode;
  MNode = RECORD (L.NameNode)
    key     : LONGINT;
    symbols : E.LSTRPTR;
    imports : L.NameList;
    path    : E.LSTRPTR;
  END; (* MNode *)

  MList = RECORD (L.NameList) END;

VAR
  ModuleList  : L.NameList; (* List of modules discovered. *)
  Dependants  : MList;  (* List of dependant modules. *)

(*------------------------------------*)
PROCEDURE (VAR list : MList) Enqueue * (node : L.NodePtr);

  VAR next : L.NodePtr;

BEGIN (* Enqueue *)
  WITH node : MNodePtr DO
    next := list.head;
    WHILE (next # NIL) & (next(MNodePtr).key <= node.key) DO
      next := next.succ
    END;
    IF next = NIL THEN list.AddTail (node)
    ELSE list.Insert (node, next.pred)
    END
  END;
END Enqueue;

(*------------------------------------*)
PROCEDURE Init ();
(*
 *  Simply initialises global variables.
 *)

BEGIN (* Init *)
  Extension := SYS.ADR (DefaultExtension);
  ModuleList.NewList;
  Dependants.NewList
END Init;


(*------------------------------------*)
PROCEDURE GetArgs ();
(*
 *  Parses the command line arguments.
 *)

  CONST DuplicateArg = " !! Argument duplicated\n\n";
        PathMissing  = " !! <path> missing\n\n";
        ModAndAll    = " !! both <module> and ALL specified\n\n";
        TooManySyms  = " !! Too many symbol file search paths\n";
        TooManySrcs  = " !! Too many source file search paths\n";
        CmdMissing   = " !! <command> missing\n\n";
        ExtMissing   = " !! <extension> missing\n\n";
        WithMissing  = " !! <file> missing\n\n";
        ArgTooLong   = " !! Argument in WITH file too long\n";
        BadArg       = " !! Unrecognised argument in WITH file\n";

  VAR moduleFound, destFound, cmdFound, extFound : BOOLEAN; arg : INTEGER;
      argStr : ARRAY 256 OF CHAR;

  (*------------------------------------*)
  PROCEDURE Greeting ();

  BEGIN (* Greeting *)
    Out.String (ORURev.vString);
    Out.String (CopyrightStr);
    Out.String (UsageStr);
    Out.Ln
  END Greeting;

  (*------------------------------------*)
  PROCEDURE Usage ();

  BEGIN (* Usage *)
    Out.String ("Usage:   ORU {option} <module>|ALL\n\n");
    Out.String ("Options: NOTCD {WITH <file>}\n");
    Out.String ("         {SYM | SYMBOLS <path>}\n");
    Out.String ("         {SRC | SOURCE} <path>}\n");
    Out.String ("         DST | DESTINATION <path>\n");
    Out.String ("         EXT | EXTENSION <extension>\n\n");
  END Usage;

  (*------------------------------------*)
  PROCEDURE ParseWithFile (VAR fileName : ARRAY OF CHAR);

    VAR file : Files.File; r : Files.Rider; argStr : ARRAY 256 OF CHAR;

    (*------------------------------------*)
    PROCEDURE BailOut (msg : ARRAY OF CHAR);

    <*$CopyArrays-*>
    BEGIN (* BailOut *)
      Out.String (msg); Usage (); Files.Close (file); HALT (10)
    END BailOut;

    (*------------------------------------*)
    PROCEDURE BailOut2 (msg : ARRAY OF CHAR);

    <*$CopyArrays-*>
    BEGIN (* BailOut2 *)
      Out.String (msg); Files.Close (file); HALT (10)
    END BailOut2;

    (*------------------------------------*)
    PROCEDURE GetNextArg ();

      VAR i : LONGINT; ch : CHAR;

    BEGIN (* GetNextArg *)
      Files.Read (r, ch);
      (* Skip white space *)
      WHILE (ch <= " ") & ~r.eof DO Files.Read (r, ch) END;
      IF r.eof THEN
        RETURN
      ELSIF ch = 22X THEN
        (* Quoted argument *)
        i := 0; Files.Read (r, ch);
        WHILE (i < 255) & (ch # 22X) & ~r.eof DO
          argStr [i] := ch; INC (i); Files.Read (r, ch)
        END;
        argStr [i] := 0X;
        IF ch = 22X THEN Files.Read (r, ch)
        ELSIF ~r.eof THEN BailOut2 (ArgTooLong)
        END;
      ELSE
        i := 0;
        WHILE (i < 255) & (ch > " ") & ~r.eof DO
          argStr [i] := ch; INC (i); Files.Read (r, ch)
        END;
        argStr [i] := 0X;
        IF (ch > " ") & ~r.eof THEN BailOut2 (ArgTooLong) END
      END; (* ELSE *)
    END GetNextArg;

    (*------------------------------------*)
    PROCEDURE CopyArg () : E.LSTRPTR;

      VAR copy : E.LSTRPTR;

    BEGIN (* CopyArg *)
      SYS.NEW (copy, SYS.STRLEN (argStr) + 1);
      COPY (argStr, copy^);
      RETURN copy
    END CopyArg;

  BEGIN (* ParseWithFile *)
    file := Files.Old (fileName);
    IF file # NIL THEN
      Files.Set (r, file, 0); GetNextArg ();
      WHILE ~r.eof DO
        Str.Cap (argStr);
        IF argStr = "NOTCD" THEN
          IF NotCD THEN BailOut (DuplicateArg) END;
          NotCD := TRUE
        ELSIF (argStr = "SYM") OR (argStr = "SYMBOLS") THEN
          GetNextArg ();
          IF r.eof THEN BailOut (PathMissing)
          ELSIF NumSymbols >= MaxPaths THEN
          BailOut2 (TooManySyms)
          END;
          Symbols [NumSymbols] := CopyArg ();
          INC (NumSymbols); Symbols [NumSymbols] := NIL;
        ELSIF (argStr = "SRC") OR (argStr = "SOURCE") THEN
          GetNextArg ();
          IF r.eof THEN BailOut (PathMissing)
          ELSIF NumSources >= MaxPaths THEN BailOut2 (TooManySrcs)
          END;
          Source [NumSources] := CopyArg ();
          INC (NumSources); Source [NumSources] := NIL;
        ELSIF (argStr = "EXT") OR (argStr = "EXTENSION") THEN
          GetNextArg ();
          IF r.eof OR extFound THEN
            IF extFound THEN BailOut (DuplicateArg)
            ELSE BailOut (ExtMissing)
            END;
          END;
          Extension := CopyArg (); extFound := TRUE
        ELSE
          BailOut (BadArg)
        END; (* ELSE *)
        GetNextArg ();
      END; (* WHILE *)
      Files.Set (r, NIL, 0); Files.Close (file);
    ELSE
      Out.String (" !! Could not open "); Out.String (fileName); Out.Ln
    END; (* ELSE *)
  END ParseWithFile;

  (*------------------------------------*)
  PROCEDURE BailOut (msg : ARRAY OF CHAR);

  <*$CopyArrays-*>
  BEGIN (* BailOut *)
    Out.String (msg); Usage ();  HALT (10)
  END BailOut;

  (*------------------------------------*)
  PROCEDURE BailOut2 (msg : ARRAY OF CHAR);

  <*$CopyArrays-*>
  BEGIN (* BailOut2 *)
    Out.String (msg); HALT (10)
  END BailOut2;

BEGIN (* GetArgs *)
  moduleFound := FALSE; destFound := FALSE; cmdFound := FALSE;
  extFound := FALSE;
  IF Args.IsCLI THEN
    Greeting ();
    IF Args.argc < 2 THEN
      (* Minimum of one argument needed *)
      BailOut (" !! Arguments missing\n\n")
    END;
    Symbols [0] := SYS.ADR (DefaultPath);
    NumSymbols := 1; Symbols [1] := NIL;
    arg := 1; (* first argument is the program name, so ignore it. *)
    WHILE arg < Args.argc DO
      COPY (Args.argv [arg]^, argStr); Str.Cap (argStr);
      IF argStr = "NOTCD" THEN
        IF NotCD THEN BailOut (DuplicateArg) END;
        NotCD := TRUE
      ELSIF (argStr = "SYM") OR (argStr = "SYMBOLS") THEN
        INC (arg);
        IF arg >= Args.argc THEN BailOut (PathMissing)
        ELSIF NumSymbols >= MaxPaths THEN BailOut2 (TooManySyms)
        END;
        Symbols [NumSymbols] := Args.argv [arg];
        INC (NumSymbols); Symbols [NumSymbols] := NIL;
      ELSIF (argStr = "SRC") OR (argStr = "SOURCE") THEN
        INC (arg);
        IF arg >= Args.argc THEN BailOut (PathMissing)
        ELSIF NumSources >= MaxPaths THEN BailOut2 (TooManySrcs)
        END;
        Source [NumSources] := Args.argv [arg];
        INC (NumSources); Source [NumSources] := NIL;
      ELSIF (argStr = "DST") OR (argStr = "DESTINATION") THEN
        INC (arg);
        IF (arg >= Args.argc) OR destFound THEN
          IF destFound THEN BailOut (DuplicateArg)
          ELSE BailOut (PathMissing)
          END;
        END;
        Destination := Args.argv [arg]; destFound := TRUE
      ELSIF (argStr = "EXT") OR (argStr = "EXTENSION") THEN
        INC (arg);
        IF (arg >= Args.argc) OR extFound THEN
          IF extFound THEN BailOut (DuplicateArg)
          ELSE BailOut (ExtMissing)
          END;
        END;
        Extension := Args.argv [arg]; extFound := TRUE
      ELSIF argStr = "ALL" THEN
        IF All THEN BailOut (DuplicateArg)
        ELSIF moduleFound THEN BailOut (ModAndAll)
        END;
        Module := SYS.ADR("All"); All := TRUE
      ELSIF argStr = "WITH" THEN
        INC (arg);
        IF arg >= Args.argc THEN BailOut (WithMissing) END;
        ParseWithFile (Args.argv [arg]^)
      ELSE
        IF moduleFound THEN BailOut (DuplicateArg)
        ELSIF All THEN BailOut (ModAndAll)
        END;
        Module := Args.argv [arg]; moduleFound := TRUE
      END; (* ELSE *)
      INC (arg)
    END; (* WHILE *)
    IF ~moduleFound & ~All THEN BailOut (" !! <module> missing\n\n") END;
  ELSE
    IU.SimpleNotice
      (NIL, SYS.ADR ("Sorry, no support for Workbench yet :-("));
    HALT (10)
  END; (* ELSE *)
END GetArgs;


(*------------------------------------*)
PROCEDURE SearchSymbolFile (directory : E.LSTRPTR; fileName : ARRAY OF CHAR);

  VAR
    F : Files.File; R : Files.Rider; tag : LONGINT; modName : ModName;
    module : MNodePtr; import : L.NameNodePtr;

  (*------------------------------------*)
  PROCEDURE ReadModAnchor (VAR n : ARRAY OF CHAR) : BOOLEAN;

    CONST
      BadName = "\x9B\x4B !! Bad name in symbol file ";

    VAR s : SHORTINT; ch : CHAR; key : LONGINT;

  BEGIN (* ReadModAnchor *)
    Files.Read (R, s); (* modAnchor *)
    IF s = eMod THEN
      Files.ReadBytes (R, key, 4); s := 0;
      LOOP
        Files.Read (R, ch); n [s] := ch;
        IF ch = 0X THEN EXIT END;
        INC (s);
        IF s > MaxName THEN
          n [MaxName] := 0X;
          Out.String (BadName); Out.String (fileName); Out.Ln;
          WHILE ch # 0X DO Files.Read (R, ch) END;
          RETURN FALSE
        END; (* IF *)
      END; (* LOOP *)
      RETURN TRUE
    END; (* IF *)
    RETURN FALSE
  END ReadModAnchor;

<*$CopyArrays-*>
BEGIN (* SearchSymbolFile *)
  Out.String ("\x9B\x4B << "); Out.String (fileName); Out.Char (0DX);
  F := Files.Old (fileName);
  IF F = NIL THEN Out.String (OpenError); Out.String (fileName); Out.Ln;
  ELSE
    Files.Set (R, F, 0); Files.ReadBytes (R, tag, 4);
    IF tag # SymFileTag THEN
      Out.String ("\x9B\x4B !! "); Out.String (fileName);
      Out.String (" is obsolete, or is not a symbol file"); Out.Ln
    ELSE
      IF ReadModAnchor (modName) THEN
        NEW (module);
        module.Name (modName); module.key := 0;
        module.symbols := directory; module.imports.NewList;
        ModuleList.AddTail (module);
        WHILE ReadModAnchor (modName) DO
          NEW (import); import.Name (modName);
          module.imports.AddTail (import);
        END;
      END;
    END;
    Files.Set (R, NIL, 0); Files.Close (F)
  END;
END SearchSymbolFile;


(*------------------------------------*)
PROCEDURE ScanForSymbols (directory : E.LSTRPTR);

  CONST
    LockError    = " !! Failed to lock ";

  VAR
    lock, oldLock : D.FileLockPtr;
    myAnchor : D.AnchorPathPtr;
    result : LONGINT;

BEGIN (* ScanForSymbols *)
  IF directory = NIL THEN directory := SYS.ADR ("") END;
  lock := D.Lock (directory^, D.sharedLock);
  IF lock = NIL THEN
    Out.String (LockError); Out.String (directory^); Out.Ln; RETURN
  END;

  oldLock := D.CurrentDir (lock);

  NEW (myAnchor); myAnchor.strlen := SHORT (LEN (myAnchor.buf));
  result := D.MatchFirst ("#?.sym", myAnchor^);
  WHILE result = 0 DO
    SearchSymbolFile (directory, myAnchor.buf);
    result := D.MatchNext (myAnchor^)
  END;
  D.MatchEnd (myAnchor^);

  oldLock := D.CurrentDir (oldLock);
  D.UnLock (lock)
END ScanForSymbols;


(*------------------------------------*)
PROCEDURE SearchForDependants (modName : ARRAY OF CHAR; level : LONGINT);

  VAR node, module, import : L.NodePtr;

<*$CopyArrays-*>
BEGIN (* SearchForDependants *)
  module := ModuleList.FindCap (modName);
  IF module = NIL THEN
    Out.String (" !! Module "); Out.String (modName);
    Out.String (" not found\n"); Out.Ln
  ELSE
    IF module(MNodePtr).key < level THEN
      module(MNodePtr).key := level;
      node := ModuleList.head;
      WHILE node # NIL DO
        WITH node : MNodePtr DO
          import := node.imports.FindCap (modName);
          IF import # NIL THEN
            SearchForDependants (node.name^, level + 1)
          END;
        END;
        node := node.succ
      END;
    END;
  END;
END SearchForDependants;


(*------------------------------------*)
PROCEDURE SearchForAll ();

  VAR node, module, import : L.NodePtr;

BEGIN (* SearchForAll *)
  module := ModuleList.head;
  WHILE module # NIL DO
    IF module(MNodePtr).key = 0 THEN
      module(MNodePtr).key := 1;
      node := ModuleList.head;
      WHILE node # NIL DO
        WITH node : MNodePtr DO
          import := node.imports.Find (module(L.NameNodePtr).name^);
          IF import # NIL THEN
            SearchForDependants (node.name^, 2)
          END;
        END; (* WITH node *)
        node := node.succ
      END; (* WHILE *)
    END;
    module := module.succ;
  END; (* WHILE *)
END SearchForAll;


(*------------------------------------*)
PROCEDURE SortDependants ();

  VAR node : L.NodePtr;

BEGIN (* SortDependants *)
  LOOP
    node := ModuleList.RemHead ();
    IF node = NIL THEN EXIT END;
    WITH node : MNodePtr DO
      IF node.key > 0 THEN Dependants.Enqueue (node) END
    END; (* WITH *)
  END; (* LOOP *)
END SortDependants;


(*------------------------------------*)
PROCEDURE FileExists (path : ARRAY OF CHAR) : BOOLEAN;

  VAR lock : D.FileLockPtr; result : BOOLEAN;

<*$CopyArrays-*>
BEGIN (* FileExists *)
  result := FALSE;
  lock := D.Lock (path, D.sharedLock);
  IF lock # NIL THEN result := TRUE; D.UnLock (lock) END;
  RETURN result
END FileExists;

(*------------------------------------*)
PROCEDURE Search (file : ARRAY OF CHAR; VAR path : E.LSTRPTR) : BOOLEAN;

  VAR
    index : INTEGER; fullPath : ARRAY 256 OF CHAR;
    len : LONGINT; ch : CHAR;

<*$CopyArrays-*>
BEGIN (* Search *)
  path := NIL;
  IF NotCD THEN
    IF Source [0] = NIL THEN RETURN FALSE END;
    COPY (Source [0]^, fullPath); index := 0
  ELSE
    fullPath [0] := 0X; index := -1
  END;
  LOOP
    len := Str.Length (fullPath);
    IF len > 0 THEN
      ch := fullPath [len - 1];
      IF (ch # "/") & (ch # ":") THEN Str.Append ("/", fullPath) END
    END;
    Str.Append (file, fullPath); Str.Append (Extension^, fullPath);
    IF FileExists (fullPath) THEN
      IF index >= 0 THEN path := Source [index] END;
      RETURN TRUE
    END;
    INC (index);
    IF Source [index] = NIL THEN RETURN FALSE
    ELSE COPY (Source [index]^, fullPath)
    END
  END
END Search;

(*------------------------------------*)
PROCEDURE SearchForSources ();

  VAR node, succ : L.NodePtr;

BEGIN (* SearchForSources *)
  node := Dependants.head;
  WHILE node # NIL DO
    succ := node.succ;
    WITH node : MNodePtr DO
      IF ~Search (node.name^, node.path) THEN
        Dependants.Remove (node)
      END
    END;
    node := succ
  END;
END SearchForSources;


(*------------------------------------*)
PROCEDURE OutputModules (batchFile : ARRAY OF CHAR);

  VAR
    F : Files.File; R : Files.Rider; module : L.NodePtr;
    len : LONGINT; ch : CHAR;

<*$CopyArrays-*>
BEGIN (* OutputModules *)
  F := Files.New (batchFile);
  IF F = NIL THEN
    Out.String (OpenError); Out.String (batchFile); Out.Ln
  ELSE
    Files.Set (R, F, 0);
    module := Dependants.head;
    WHILE module # NIL DO
      WITH module : MNodePtr DO
        IF module.path # NIL THEN
          len := Str.Length (module.path^);
          IF len > 0 THEN
            Files.WriteBytes (R, module.path^, len);
            ch := module.path^ [len - 1];
            IF (ch # "/") & (ch # ":") THEN Files.Write (R, "/") END;
          END
        END;
        Files.WriteBytes (R, module.name^, Str.Length (module.name^));
      END;
      Files.WriteBytes (R, Extension^, Str.Length (Extension^));
      Files.Write (R, "\n");
      module := module.succ
    END;
    Files.Set (R, NIL, 0); Files.Register (F)
  END;
END OutputModules;


(*------------------------------------*)
PROCEDURE Main ();
(*
 *  The main body of the program.
 *
 *  The basic sequence is:
 *
 *    * Scan the current directory and the Symbols list.  With each symbol
 *      file found:
 *        * Add the module to the list of modules found.
 *        * Open the symbol file and create a list of the modules it
 *          imports.
 *    * Search the module list for modules that import the redefined module
 *      and add them to a list of dependant modules.
 *    * Search the current directory and the Sources list for the source
 *      files of the dependant modules.
 *    * Output the list to the script file using the command template.
 *)

  VAR index : INTEGER; batchFile : ARRAY 256 OF CHAR;
    len : LONGINT; ch : CHAR;

BEGIN (* Main *)
  Out.String (" !! Scanning for symbol files\n");
  IF ~NotCD THEN
    Out.String ("    Scanning current directory\n"); ScanForSymbols (NIL)
  END;

  index := 0;
  WHILE Symbols [index] # NIL DO
    Out.String ("\x9B\x4B    Scanning "); Out.String (Symbols [index]^);
    Out.Ln;
    ScanForSymbols (Symbols [index]); INC (index)
  END;

  IF All THEN
    Out.String ("\x9B\x4B !! Searching for all dependant modules"); Out.Ln;
    SearchForAll ()
  ELSE
    Out.String ("\x9B\x4B !! Searching for dependants of ");
    Out.String (Module^); Out.Ln;
    SearchForDependants (Module^, 1);
  END; (* ELSE *)

  Out.String ("\x9B\x4B !! Sorting dependant modules\n");
  SortDependants ();

  Out.String ("\x9B\x4B !! Searching for source files\n");
  SearchForSources ();

  IF Destination = NIL THEN
    batchFile := ""
  ELSE
    COPY (Destination^, batchFile); len := Str.Length (batchFile);
    IF len > 0 THEN
      ch := batchFile [len - 1];
      IF (ch # "/") & (ch # ":") THEN Str.Append ("/", batchFile) END
    END
  END;
  Str.Append (Module^, batchFile); Str.Append (".bat", batchFile);
  Out.String ("\x9B\x4B !! Creating batch file "); Out.String (batchFile);
  Out.Ln;
  OutputModules (batchFile)
END Main;


BEGIN (* ORU *)
  Errors.Init;
  Init ();
  GetArgs ();
  Main ();
END ORU.

(***************************************************************************

  $Log: ORU.mod $
  Revision 2.8  1995/01/26  02:13:59  fjc
  - Release 1.5

  Revision 2.7  1994/09/25  18:30:40  fjc
  - Uses new syntax for external code declarations

  Revision 2.6  1994/09/03  16:32:01  fjc
  - Gets version string from ORURev.

  Revision 2.5  1994/08/08  16:38:47  fjc
  Release 1.4

  Revision 2.4  1994/06/17  18:09:17  fjc
  - Updated for release

  Revision 2.3  1994/06/05  00:11:07  fjc
  - Updated symbol file tag to new version
  - Changed to use new Amiga interface

  Revision 2.2  1994/05/21  22:47:40  fjc
  - Removed case-sensitivity of module parameter
  - Appends "/" to paths not ending in "/" or ":"

  Revision 2.1  1994/05/19  23:23:19  fjc
  - Bumped version number.
  - Changed to generate a batch file to be used with the BATCH
    option of the compiler.
  - OLIB: is now the default symbol file search path.

  Revision 1.3  1994/05/11  23:40:54  fjc
  - Added copyright notice to file header
  - Changed greeting

  Revision 1.2  1994/01/25  10:07:37  fjc
  - Updated greeting

  Revision 1.1  1994/01/15  19:02:30  fjc
  - Start of revision control

  0.4  (02-Jan-94)  Recognises new symbol file tags.
  0.3  (28-Dec-93)  Increased MaxPaths.
  0.2  (30-Sep-93)  Add ALL and WITH options.
  0.1  (06-Sep-93)  First public release.
  0.0  (27-Aug-93)  Initial version.

***************************************************************************)